home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / balistio.c < prev    next >
Text File  |  1993-08-23  |  5KB  |  257 lines
  1. /* balistio.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. #define UIO_SERVER             1
  25. #define SERVER_EMULATOR_FILE   1
  26. #define SKIP_COMPAT_DATA       1
  27. #include "userutl.h"
  28.  
  29. #include <math.h>
  30.  
  31. #include "uio_strc.h"
  32. #include "uio_tran.h"
  33. #include "uio_reqs.pro"
  34. #include "uio_cmds.pro"
  35.  
  36. #ifdef MAC
  37. #include "macuio.redef"
  38. #endif
  39.  
  40. #define TORAD(x)  ((x)*.017453293)  /* degrees to radians */
  41.  
  42. REAL impact( alpha, vi, h )   /* compute impact distance */
  43. REAL alpha;   /* firing angle */
  44. REAL vi;    /* firing velocity */
  45. REAL h;   /* height */
  46. {
  47.   REAL g;        /* gravity */
  48.   REAL ta;
  49.   REAL sina;     /* sin(alpha) */
  50.   REAL visina;   /* vi * sin(alpha) */
  51.   REAL li;       /* impact point */
  52.  
  53.   g = 32.0;         /* gravity */
  54.   sina  = sin(TORAD(alpha));
  55.   visina  = vi * sina;
  56.   ta  = (visina + sqrt( visina*visina + 2 * g * h ) ) / g;
  57.   li  = vi * cos(TORAD(alpha)) * ta;
  58.  
  59.   return( li );
  60. }
  61.  
  62. LOCAL REAL hit;
  63.  
  64. /*******************************************************************/
  65. /*                                                                 */
  66. /* Functions necessary for handling the User I/O package itself.   */
  67. /*                                                                 */
  68. /*******************************************************************/
  69.  
  70. NINT UIO_Init(file)
  71. TEXT *file;
  72. {
  73.    NINT ret_val = UIO_OK;
  74.    
  75.    return(ret_val);
  76. }
  77.  
  78.  
  79. NINT UIO_Term(process)
  80. NINT process;
  81. {
  82.    NINT ret_val = UIO_OK;
  83.    
  84.    return(ret_val);
  85. }
  86.  
  87. NINT UIO_Attention()
  88. {
  89.    NINT ret_val = UIO_OK;
  90.    
  91.    
  92.    return(ret_val);
  93. }
  94.  
  95. NINT UIO_Learn_Start()
  96. {
  97.    NINT ret_val = UIO_OK;
  98.    
  99.    return(ret_val);
  100. }
  101.  
  102. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  103. NINT  LayN;
  104. NINT  nPEs;
  105. SREAL *Datap;
  106. {
  107.    NINT ret_val = UIO_OK;
  108.    
  109.    return(ret_val);
  110. }
  111.  
  112. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  113. NINT  LayN;
  114. NINT  nPEs;
  115. SREAL *Datap;
  116. {
  117.    NINT ret_val = UIO_OK;
  118.    
  119.    return(ret_val);
  120. }
  121.  
  122.  
  123. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  124. NINT  LayN;
  125. NINT  nPEs;
  126. SREAL *Datap;
  127. {
  128.    NINT ret_val = UIO_OK;
  129.    
  130.    return(ret_val);
  131. }
  132.  
  133.  
  134. NINT UIO_Learn_End()
  135. {
  136.    NINT ret_val = UIO_OK;
  137.    
  138.    return(ret_val);
  139. }
  140.  
  141.  
  142. NINT UIO_Recall_Start()
  143. {
  144.    NINT ret_val = UIO_OK;
  145.  
  146.    return(ret_val);
  147. }
  148.  
  149. NINT UIO_Read(LayN, nPEs, Datap)
  150. NINT  LayN;
  151. NINT  nPEs;
  152. SREAL *Datap;
  153. {
  154.    NINT ret_val = UIO_OK;
  155.    REAL alpha;    /* angle */
  156.    REAL vi;       /* velocity */
  157.    REAL height;   /* height */
  158.    TEXT *sp;
  159.    
  160.    PutStr("\nEnter Alpha (0-90), Vi (0-100), H (0-100) or E=end: " );
  161.    sp = GetStr();
  162.  
  163.    if ( *sp == 'e' || *sp == 'E' || *sp == '\033' ) {
  164.       ret_val = UIO_ERROR;
  165.    } else {
  166. #ifdef THINK_C
  167.       sscanf( sp, "%Lf %Lf %Lf", &alpha, &vi, &height );
  168. #else
  169.       sscanf( sp, "%lf %lf %lf", &alpha, &vi, &height );
  170. #endif
  171.       
  172.       hit = impact( alpha, vi, height );
  173.       Datap[0] = alpha;
  174.       Datap[1] = vi;
  175.       Datap[2] = height;
  176.    }
  177.    return(ret_val);
  178. }
  179.  
  180. NINT UIO_Write(LayN, nPEs, Datap)
  181. NINT  LayN;
  182. NINT  nPEs;
  183. SREAL *Datap;
  184. {
  185.    TEXT buf[100];
  186.  
  187.    sprintf( buf, "Network Hit = %.3lf, computed impact = %.3lf",
  188.            Datap[0], hit );
  189.    PutStr( buf );
  190.  
  191.    return(UIO_UPDATE);
  192. }
  193.  
  194. NINT UIO_Write_Step(LayN, nPEs, Datap)
  195. NINT  LayN;
  196. NINT  nPEs;
  197. SREAL *Datap;
  198. {
  199.    NINT ret_val = UIO_OK;
  200.    
  201.    return(ret_val);
  202. }
  203.  
  204. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  205. NINT  LayN;
  206. NINT  nPEs;
  207. SREAL *Datap;
  208. {
  209.    NINT ret_val = UIO_OK;
  210.    
  211.    Datap[0] = hit;
  212.    return(ret_val);
  213. }
  214.  
  215. NINT UIO_Recall_End()
  216. {
  217.    NINT ret_val = UIO_OK;
  218.    
  219.    return(ret_val);
  220. }
  221.  
  222. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  223. NINT  Instrument_id;
  224. NINT  nDataElems;
  225. SREAL *DataElemp;
  226. {
  227.    NINT ret_val = UIO_OK;
  228.    
  229.    return(ret_val);
  230. }
  231.  
  232. NINT UIO_ObjFunc(eoeflag, DataElemp)
  233. NINT  eoeflag;
  234. SREAL *DataElemp;
  235. {
  236.    NINT ret_val = UIO_OK;
  237.    
  238.    return(ret_val);
  239. }
  240.  
  241. NINT UIO_Rewind()
  242. {
  243.    NINT ret_val = UIO_OK;
  244.    
  245.    return(ret_val);
  246. }
  247.  
  248. NINT UIO_Explain(LayN, nPEs, Datap)
  249. NINT  LayN;
  250. NINT  nPEs;
  251. SREAL *Datap;
  252. {
  253.    NINT ret_val = UIO_OK;
  254.    
  255.    return(ret_val);
  256. }
  257.